home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 October: Mac OS SDK / Dev.CD Oct 00 SDK1.toast / Development Kits / Cross Platform / QuickTime 4.1.2 Windows SDK / CIncludes / QTStreamingComponents.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-04-12  |  40.5 KB  |  1,105 lines  |  [TEXT/R*ch]
  1. /*
  2.      File:        QTStreamingComponents.h
  3.  
  4.      Contains:    QuickTime interfaces
  5.  
  6.      Version:    Technology:    
  7.                  Release:    QuickTime 4.1
  8.  
  9.      Copyright:    (c) 1990-1999 by Apple Computer, Inc., all rights reserved
  10.  
  11.      Bugs?:        For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. */
  17. #ifndef __QTSTREAMINGCOMPONENTS__
  18. #define __QTSTREAMINGCOMPONENTS__
  19.  
  20. #ifndef __COMPONENTS__
  21.     #include <Components.h>
  22. #endif
  23.  
  24. #ifndef __MOVIES__
  25.     #include <Movies.h>
  26. #endif
  27.  
  28. #ifndef __QUICKTIMESTREAMING__
  29.     #include <QuickTimeStreaming.h>
  30. #endif
  31.  
  32.  
  33.  
  34.  
  35. #if PRAGMA_ONCE
  36. #pragma once
  37. #endif
  38.  
  39. #ifdef __cplusplus
  40. extern "C" {
  41. #endif
  42.  
  43. #if PRAGMA_IMPORT
  44. #pragma import on
  45. #endif
  46.  
  47. #if PRAGMA_STRUCT_ALIGN
  48.     #pragma options align=mac68k
  49. #elif PRAGMA_STRUCT_PACKPUSH
  50.     #pragma pack(push, 2)
  51. #elif PRAGMA_STRUCT_PACK
  52.     #pragma pack(2)
  53. #endif
  54.  
  55. /*============================================================================
  56.         Stream Handler
  57. ============================================================================*/
  58.  
  59. /*
  60.     Server edits are only valid for the current chunk
  61. */
  62.  
  63. struct SHServerEditParameters {
  64.     UInt32                             version;
  65.     Fixed                             editRate;
  66.     TimeValue64                     dataStartTime_mediaAxis;
  67.     TimeValue64                     dataEndTime_mediaAxis;
  68. };
  69. typedef struct SHServerEditParameters    SHServerEditParameters;
  70. enum {
  71.     kSHNoChunkDispatchFlags        = 0,
  72.     kSHChunkFlagSyncSample        = 1 << 2,
  73.     kSHChunkFlagDataLoss        = 1 << 4
  74. };
  75.  
  76.  
  77. struct SHChunkRecord {
  78.     UInt32                             version;
  79.     long                             reserved1;
  80.     SInt32                             flags;
  81.     UInt32                             dataSize;
  82.     UInt8 *                            dataPtr;
  83.     long                             reserved2;
  84.     long                             reserved3;
  85.     TimeValue64                     presentationTime;
  86.  
  87.     long                             reserved4;
  88.     long                             reserved5;
  89.     const SHServerEditParameters *    serverEditParameters;
  90.     long                             reserved6;
  91.     long                             reserved7;
  92. };
  93. typedef struct SHChunkRecord            SHChunkRecord;
  94.  
  95. /*============================================================================
  96.         RTP Components
  97. ============================================================================*/
  98.  
  99. typedef UInt32                             RTPSSRC;
  100. enum {
  101.     kRTPInvalidSSRC                = 0
  102. };
  103.  
  104.  
  105. /* RTP standard content encodings for audio */
  106. enum {
  107.     kRTPPayload_PCMU            = 0,                            /* 8kHz PCM mu-law mono */
  108.     kRTPPayload_1016            = 1,                            /* 8kHz CELP (Fed Std 1016) mono */
  109.     kRTPPayload_G721            = 2,                            /* 8kHz G.721 ADPCM mono */
  110.     kRTPPayload_GSM                = 3,                            /* 8kHz GSM mono */
  111.     kRTPPayload_G723            = 4,                            /* 8kHz G.723 ADPCM mono */
  112.     kRTPPayload_DVI_8            = 5,                            /* 8kHz Intel DVI ADPCM mono */
  113.     kRTPPayload_DVI_16            = 6,                            /* 16kHz Intel DVI ADPCM mono */
  114.     kRTPPayload_LPC                = 7,                            /* 8kHz LPC */
  115.     kRTPPayload_PCMA            = 8,                            /* 8kHz PCM a-law mono */
  116.     kRTPPayload_L16_44_2        = 10,                            /* 44.1kHz 16-bit linear stereo */
  117.     kRTPPayload_L16_44_1        = 11,                            /* 44.1kHz 16-bit linear mono */
  118.     kRTPPayload_PureVoice        = 12,                            /* 8kHz PureVoice mono (QCELP) */
  119.     kRTPPayload_MPEGAUDIO        = 14,                            /* MPEG I and II audio */
  120.     kRTPPayload_DVI_11            = 16,                            /* 11kHz Intel DVI ADPCM mono */
  121.     kRTPPayload_DVI_22            = 17                            /* 22kHz Intel DVI ADPCM mono */
  122. };
  123.  
  124. /* RTP standard content encodings for video */
  125. enum {
  126.     kRTPPayload_CELLB            = 25,                            /* Sun CellB */
  127.     kRTPPayload_JPEG            = 26,                            /* JPEG */
  128.     kRTPPayload_CUSEEME            = 27,                            /* Cornell CU-SeeMe */
  129.     kRTPPayload_NV                = 28,                            /* Xerox PARC nv */
  130.     kRTPPayload_PICWIN            = 29,                            /* BBN Picture Window */
  131.     kRTPPayload_CPV                = 30,                            /* Bolter CPV */
  132.     kRTPPayload_H261            = 31,                            /* CCITT H.261 */
  133.     kRTPPayload_MPEGVIDEO        = 32,                            /* MPEG I and II video */
  134.     kRTPPayload_H263            = 34                            /* CCITT H.263 */
  135. };
  136.  
  137. /* Other RTP standard content encodings */
  138. enum {
  139.     kRTPPayload_MPEG2T            = 33                            /* MPEG 2 Transport */
  140. };
  141.  
  142. /* Dynamic encodings */
  143. enum {
  144.     kRTPPayload_FirstDynamic    = 96,
  145.     kRTPPayload_LastDynamic        = 127,
  146.     kRTPPayload_Unknown            = 0xFF
  147. };
  148.  
  149.  
  150.  
  151. /*
  152. -----------------------------------------
  153.     RTP Info selectors
  154. -----------------------------------------
  155. */
  156. /* ----- these are get and set ----- */
  157. enum {
  158.     kRTPBufferDelayInfo            = FOUR_CHAR_CODE('bufr')        /* UInt32 in time scale*/
  159. };
  160.  
  161. /*-----------------------------------------
  162.     RTP Statistics
  163. -----------------------------------------*/
  164. enum {
  165.     kRTPTotalReceivedPktsStat    = FOUR_CHAR_CODE('trcp'),
  166.     kRTPTotalLostPktsStat        = FOUR_CHAR_CODE('tlsp'),
  167.     kRTPTotalProcessedPktsStat    = FOUR_CHAR_CODE('tprp'),
  168.     kRTPTotalDroppedPktsStat    = FOUR_CHAR_CODE('tdrp'),
  169.     kRTPBadHeaderDroppedPktsStat = FOUR_CHAR_CODE('bhdp'),
  170.     kRTPOurHeaderDroppedPktsStat = FOUR_CHAR_CODE('ohdp'),
  171.     kRTPNotReceivingSenderDroppedPktsStat = FOUR_CHAR_CODE('nsdp'),
  172.     kRTPNotProcessingDroppedPktsStat = FOUR_CHAR_CODE('npdp'),
  173.     kRTPBadSeqDroppedPktsStat    = FOUR_CHAR_CODE('bsdp'),
  174.     kRTPArriveTooLatePktsStat    = FOUR_CHAR_CODE('artl'),
  175.     kRTPWaitForSeqDroppedPktsStat = FOUR_CHAR_CODE('wsdp'),
  176.     kRTPBadStateDroppedPktsStat    = FOUR_CHAR_CODE('stdp'),
  177.     kRTPBadPayloadDroppedPktsStat = FOUR_CHAR_CODE('bpdp'),
  178.     kRTPNoTimeScaleDroppedPktsStat = FOUR_CHAR_CODE('ntdp'),
  179.     kRTPDupSeqNumDroppedPktsStat = FOUR_CHAR_CODE('dsdp'),
  180.     kRTPLostPktsPercentStat        = FOUR_CHAR_CODE('lspp'),
  181.     kRTPDroppedPktsPercentStat    = FOUR_CHAR_CODE('dppp'),
  182.     kRTPTotalUnprocessedPktsPercentStat = FOUR_CHAR_CODE('tupp'),
  183.     kRTPRTCPDataRateStat        = FOUR_CHAR_CODE('rrcd'),
  184.     kRTPPayloadIDStat            = FOUR_CHAR_CODE('rpid'),
  185.     kRTPPayloadNameStat            = FOUR_CHAR_CODE('rpnm'),
  186.     kRTPNumPktsInQueueStat        = FOUR_CHAR_CODE('rnpq'),
  187.     kRTPTotalPktsInQueueStat    = FOUR_CHAR_CODE('rtpq'),
  188.     kRTPTotalOutOfOrderPktsStat    = FOUR_CHAR_CODE('rtoo')
  189. };
  190.  
  191.  
  192. /*-----------------------------------------
  193.     Payload Info
  194. -----------------------------------------*/
  195. enum {
  196.     kRTPPayloadSpeedTag            = FOUR_CHAR_CODE('sped'),        /* 0-255, 255 is fastest*/
  197.     kRTPPayloadLossRecoveryTag    = FOUR_CHAR_CODE('loss')        /* 0-255, 0 can't handle any loss, 128 can handle 50% packet loss*/
  198. };
  199.  
  200.  
  201. struct RTPPayloadCharacteristic {
  202.     OSType                             tag;
  203.     long                             value;
  204. };
  205. typedef struct RTPPayloadCharacteristic    RTPPayloadCharacteristic;
  206. /*
  207.     pass RTPPayloadSortRequest to QTSFindMediaPacketizer or QTSFindMediaPacketizerForTrack.
  208.     define the characteristics to sort by. tag is key to sort on. value is positive for ascending
  209.     sort (low value first), negative for descending sort (high value first).
  210. */
  211.  
  212. struct RTPPayloadSortRequest {
  213.     long                             characteristicCount;
  214.     RTPPayloadCharacteristic         characteristic[1];            /* tag is key to sort on, value is + for ascending, - for descending*/
  215. };
  216. typedef struct RTPPayloadSortRequest    RTPPayloadSortRequest;
  217. typedef RTPPayloadSortRequest *            RTPPayloadSortRequestPtr;
  218. /* flags for RTPPayloadInfo */
  219. enum {
  220.     kRTPPayloadTypeStaticFlag    = 0x00000001,
  221.     kRTPPayloadTypeDynamicFlag    = 0x00000002
  222. };
  223.  
  224.  
  225. struct RTPPayloadInfo {
  226.     long                             payloadFlags;
  227.     UInt8                             payloadID;
  228.     char                             unused[3];
  229.     char                             payloadName[1];
  230. };
  231. typedef struct RTPPayloadInfo            RTPPayloadInfo;
  232. typedef RTPPayloadInfo *                RTPPayloadInfoPtr;
  233. typedef RTPPayloadInfoPtr *                RTPPayloadInfoHandle;
  234. /*============================================================================
  235.         RTP Reassembler
  236. ============================================================================*/
  237.  
  238. typedef ComponentInstance                 RTPReassembler;
  239. enum {
  240.     kRTPReassemblerType            = FOUR_CHAR_CODE('rtpr')
  241. };
  242.  
  243. enum {
  244.     kRTPBaseReassemblerType        = FOUR_CHAR_CODE('gnrc'),
  245.     kRTP261ReassemblerType        = FOUR_CHAR_CODE('h261'),
  246.     kRTP263ReassemblerType        = FOUR_CHAR_CODE('h263'),
  247.     kRTP263PlusReassemblerType    = FOUR_CHAR_CODE('263+'),
  248.     kRTPAudioReassemblerType    = FOUR_CHAR_CODE('soun'),
  249.     kRTPQTReassemblerType        = FOUR_CHAR_CODE('qtim'),
  250.     kRTPPureVoiceReassemblerType = FOUR_CHAR_CODE('Qclp'),
  251.     kRTPJPEGReassemblerType        = FOUR_CHAR_CODE('jpeg'),
  252.     kRTPQDesign2ReassemblerType    = FOUR_CHAR_CODE('QDM2'),
  253.     kRTPSorensonReassemblerType    = FOUR_CHAR_CODE('SVQ1')
  254. };
  255.  
  256.  
  257. struct RTPRssmInitParams {
  258.     RTPSSRC                         ssrc;
  259.     UInt8                             payloadType;
  260.     UInt8                             pad[3];
  261.     TimeBase                         timeBase;
  262.     TimeScale                         timeScale;
  263. };
  264. typedef struct RTPRssmInitParams        RTPRssmInitParams;
  265.  
  266. struct RTPRssmPacket {
  267.     struct RTPRssmPacket *            next;
  268.     struct RTPRssmPacket *            prev;
  269.     QTSStreamBuffer *                streamBuffer;
  270.     Boolean                         paramsFilledIn;
  271.     UInt8                             pad[1];
  272.     UInt16                             sequenceNum;
  273.     UInt32                             transportHeaderLength;        /* filled in by base*/
  274.     UInt32                             payloadHeaderLength;        /* derived adjusts this */
  275.     UInt32                             dataLength;
  276.     SHServerEditParameters             serverEditParams;
  277.     TimeValue64                     timeStamp;                    /* lower 32 bits is original rtp timestamp*/
  278.     SInt32                             chunkFlags;                    /* these are or'd together*/
  279.     SInt32                             flags;
  280.  
  281. };
  282. typedef struct RTPRssmPacket            RTPRssmPacket;
  283. /* flags for RTPRssmPacket struct*/
  284. enum {
  285.     kRTPRssmPacketHasMarkerBitSet = 0x00000001,
  286.     kRTPRssmPacketHasServerEditFlag = 0x00010000
  287. };
  288.  
  289. /* flags for RTPRssmSendStreamBufferRange*/
  290. enum {
  291.     kRTPRssmCanRefStreamBuffer    = 0x00000001
  292. };
  293.  
  294. /* flags for RTPRssmSendPacketList*/
  295. enum {
  296.     kRTPRssmLostSomePackets        = 0x00000001
  297. };
  298.  
  299. /* flags for RTPRssmSetFlags*/
  300. enum {
  301.     kRTPRssmEveryPacketAChunkFlag = 0x00000001,
  302.     kRTPRssmQueueAndUseMarkerBitFlag = 0x00000002,
  303.     kRTPRssmTrackLostPacketsFlag = 0x00010000,
  304.     kRTPRssmNoReorderingRequiredFlag = 0x00020000
  305. };
  306.  
  307.  
  308.  
  309. struct RTPSendStreamBufferRangeParams {
  310.     QTSStreamBuffer *                streamBuffer;
  311.     TimeValue64                     presentationTime;
  312.     UInt32                             chunkStartPosition;
  313.     UInt32                             numDataBytes;
  314.     SInt32                             chunkFlags;
  315.     SInt32                             flags;
  316.     const SHServerEditParameters *    serverEditParams;            /* NULL if no edit*/
  317. };
  318. typedef struct RTPSendStreamBufferRangeParams RTPSendStreamBufferRangeParams;
  319. /* characteristics*/
  320. enum {
  321.     kRTPRssmRequiresOrderedPacketsCharacteristic = FOUR_CHAR_CODE('rrop')
  322. };
  323.  
  324.  
  325. enum {
  326.     kRTPReassemblerInfoResType    = FOUR_CHAR_CODE('rsmi')
  327. };
  328.  
  329.  
  330. struct RTPReassemblerInfo {
  331.     long                             characteristicCount;
  332.     RTPPayloadCharacteristic         characteristic[1];
  333.  
  334.                                                                 /* after the last characteristic, the payload name (defined by the MediaPacketizerPayloadInfo*/
  335.                                                                 /* structure) is present. */
  336. };
  337. typedef struct RTPReassemblerInfo        RTPReassemblerInfo;
  338. typedef RTPReassemblerInfo *            RTPReassemblerInfoPtr;
  339. typedef RTPReassemblerInfoPtr *            RTPReassemblerInfoHandle;
  340. #define RTPReassemblerInfoToPayloadInfo(_rsmi) ((RTPPayloadInfoPtr)(&((_rsmi)->characteristic[(_rsmi)->characteristicCount])))
  341. /* RTPReassemblerInfoElement structs are padded to 32 bits */
  342. enum {
  343.     kRTPReassemblerInfoPadUpToBytes = 4
  344. };
  345.  
  346.  
  347. EXTERN_API_C( OSErr )
  348. QTSFindReassemblerForPayloadID    (UInt8                     inPayloadID,
  349.                                  RTPPayloadSortRequest * inSortInfo,
  350.                                  QTAtomContainer *        outReassemblerList);
  351.  
  352. EXTERN_API_C( OSErr )
  353. QTSFindReassemblerForPayloadName (const char *            inPayloadName,
  354.                                  RTPPayloadSortRequest * inSortInfo,
  355.                                  QTAtomContainer *        outReassemblerList);
  356.  
  357. /*-----------------------------------------
  358.     RTP Reassembler Selectors
  359. -----------------------------------------*/
  360. enum {
  361.     kRTPRssmSetCapabilitiesSelect = 0x0100,
  362.     kRTPRssmGetCapabilitiesSelect = 0x0101,
  363.     kRTPRssmSetPayloadHeaderLengthSelect = 0x0102,
  364.     kRTPRssmGetPayloadHeaderLengthSelect = 0x0103,
  365.     kRTPRssmSetTimeScaleSelect    = 0x0104,
  366.     kRTPRssmGetTimeScaleSelect    = 0x0105,
  367.     kRTPRssmNewStreamHandlerSelect = 0x0106,
  368.     kRTPRssmSetStreamHandlerSelect = 0x0107,
  369.     kRTPRssmGetStreamHandlerSelect = 0x0108,
  370.     kRTPRssmSendStreamHandlerChangedSelect = 0x0109,
  371.     kRTPRssmSetSampleDescriptionSelect = 0x010A,
  372.     kRTPRssmGetChunkAndIncrRefCountSelect = 0x010D,
  373.     kRTPRssmSendChunkAndDecrRefCountSelect = 0x010E,
  374.     kRTPRssmSendLostChunkSelect    = 0x010F,
  375.     kRTPRssmSendStreamBufferRangeSelect = 0x0110,
  376.     kRTPRssmClearCachedPackets    = 0x0111,
  377.     kRTPRssmFillPacketListParamsSelect = 0x0113,
  378.     kRTPRssmReleasePacketListSelect = 0x0114,
  379.     kRTPRssmIncrChunkRefCountSelect = 0x0115,
  380.     kRTPRssmDecrChunkRefCountSelect = 0x0116,
  381.     kRTPRssmInitializeSelect    = 0x0500,
  382.     kRTPRssmHandleNewPacketSelect = 0x0501,
  383.     kRTPRssmComputeChunkSizeSelect = 0x0502,
  384.     kRTPRssmAdjustPacketParamsSelect = 0x0503,
  385.     kRTPRssmCopyDataToChunkSelect = 0x0504,
  386.     kRTPRssmSendPacketListSelect = 0x0505,
  387.     kRTPRssmGetTimeScaleFromPacketSelect = 0x0506,
  388.     kRTPRssmSetInfoSelect        = 0x0509,
  389.     kRTPRssmGetInfoSelect        = 0x050A,
  390.     kRTPRssmHasCharacteristicSelect = 0x050B,
  391.     kRTPRssmResetSelect            = 0x050C
  392. };
  393.  
  394. /*-----------------------------------------
  395.     RTP Reassembler functions - base to derived
  396. -----------------------------------------*/
  397.  
  398. EXTERN_API( ComponentResult )
  399. RTPRssmInitialize                (RTPReassembler         rtpr,
  400.                                  RTPRssmInitParams *    inInitParams)                        FIVEWORDINLINE(0x2F3C, 0x0004, 0x0500, 0x7000, 0xA82A);
  401.  
  402. EXTERN_API( ComponentResult )
  403. RTPRssmHandleNewPacket            (RTPReassembler         rtpr,
  404.                                  QTSStreamBuffer *        inStreamBuffer,
  405.                                  SInt32                 inNumWraparounds)                    FIVEWORDINLINE(0x2F3C, 0x0008, 0x0501, 0x7000, 0xA82A);
  406.  
  407. EXTERN_API( ComponentResult )
  408. RTPRssmComputeChunkSize            (RTPReassembler         rtpr,
  409.                                  RTPRssmPacket *        inPacketListHead,
  410.                                  SInt32                 inFlags,
  411.                                  UInt32 *                outChunkDataSize)                    FIVEWORDINLINE(0x2F3C, 0x000C, 0x0502, 0x7000, 0xA82A);
  412.  
  413. EXTERN_API( ComponentResult )
  414. RTPRssmAdjustPacketParams        (RTPReassembler         rtpr,
  415.                                  RTPRssmPacket *        inPacket,
  416.                                  SInt32                 inFlags)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x0503, 0x7000, 0xA82A);
  417.  
  418. EXTERN_API( ComponentResult )
  419. RTPRssmCopyDataToChunk            (RTPReassembler         rtpr,
  420.                                  RTPRssmPacket *        inPacketListHead,
  421.                                  UInt32                 inMaxChunkDataSize,
  422.                                  SHChunkRecord *        inChunk,
  423.                                  SInt32                 inFlags)                            FIVEWORDINLINE(0x2F3C, 0x0010, 0x0504, 0x7000, 0xA82A);
  424.  
  425. EXTERN_API( ComponentResult )
  426. RTPRssmSendPacketList            (RTPReassembler         rtpr,
  427.                                  RTPRssmPacket *        inPacketListHead,
  428.                                  const TimeValue64 *    inLastChunkPresentationTime,
  429.                                  SInt32                 inFlags)                            FIVEWORDINLINE(0x2F3C, 0x000C, 0x0505, 0x7000, 0xA82A);
  430.  
  431. EXTERN_API( ComponentResult )
  432. RTPRssmGetTimeScaleFromPacket    (RTPReassembler         rtpr,
  433.                                  QTSStreamBuffer *        inStreamBuffer,
  434.                                  TimeScale *            outTimeScale)                        FIVEWORDINLINE(0x2F3C, 0x0008, 0x0506, 0x7000, 0xA82A);
  435.  
  436. EXTERN_API( ComponentResult )
  437. RTPRssmSetInfo                    (RTPReassembler         rtpr,
  438.                                  OSType                 inSelector,
  439.                                  void *                    ioParams)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x0509, 0x7000, 0xA82A);
  440.  
  441. EXTERN_API( ComponentResult )
  442. RTPRssmGetInfo                    (RTPReassembler         rtpr,
  443.                                  OSType                 inSelector,
  444.                                  void *                    ioParams)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x050A, 0x7000, 0xA82A);
  445.  
  446. EXTERN_API( ComponentResult )
  447. RTPRssmHasCharacteristic        (RTPReassembler         rtpr,
  448.                                  OSType                 inCharacteristic,
  449.                                  Boolean *                outHasIt)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x050B, 0x7000, 0xA82A);
  450.  
  451. EXTERN_API( ComponentResult )
  452. RTPRssmReset                    (RTPReassembler         rtpr,
  453.                                  SInt32                 inFlags)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x050C, 0x7000, 0xA82A);
  454.  
  455. /*-----------------------------------------
  456.     RTP Reassembler functions - derived to base
  457. -----------------------------------------*/
  458. /* ----- setup*/
  459. EXTERN_API( ComponentResult )
  460. RTPRssmSetCapabilities            (RTPReassembler         rtpr,
  461.                                  SInt32                 inFlags,
  462.                                  SInt32                 inFlagsMask)                        FIVEWORDINLINE(0x2F3C, 0x0008, 0x0100, 0x7000, 0xA82A);
  463.  
  464. EXTERN_API( ComponentResult )
  465. RTPRssmGetCapabilities            (RTPReassembler         rtpr,
  466.                                  SInt32 *                outFlags)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x0101, 0x7000, 0xA82A);
  467.  
  468. EXTERN_API( ComponentResult )
  469. RTPRssmSetPayloadHeaderLength    (RTPReassembler         rtpr,
  470.                                  UInt32                 inPayloadHeaderLength)                FIVEWORDINLINE(0x2F3C, 0x0004, 0x0102, 0x7000, 0xA82A);
  471.  
  472. EXTERN_API( ComponentResult )
  473. RTPRssmGetPayloadHeaderLength    (RTPReassembler         rtpr,
  474.                                  UInt32 *                outPayloadHeaderLength)                FIVEWORDINLINE(0x2F3C, 0x0004, 0x0103, 0x7000, 0xA82A);
  475.  
  476. EXTERN_API( ComponentResult )
  477. RTPRssmSetTimeScale                (RTPReassembler         rtpr,
  478.                                  TimeScale                 inSHTimeScale)                        FIVEWORDINLINE(0x2F3C, 0x0004, 0x0104, 0x7000, 0xA82A);
  479.  
  480. EXTERN_API( ComponentResult )
  481. RTPRssmGetTimeScale                (RTPReassembler         rtpr,
  482.                                  TimeScale *            outSHTimeScale)                        FIVEWORDINLINE(0x2F3C, 0x0004, 0x0105, 0x7000, 0xA82A);
  483.  
  484. EXTERN_API( ComponentResult )
  485. RTPRssmNewStreamHandler            (RTPReassembler         rtpr,
  486.                                  OSType                 inSHType,
  487.                                  SampleDescriptionHandle  inSampleDescription,
  488.                                  TimeScale                 inSHTimeScale,
  489.                                  ComponentInstance *    outHandler)                            FIVEWORDINLINE(0x2F3C, 0x0010, 0x0106, 0x7000, 0xA82A);
  490.  
  491. EXTERN_API( ComponentResult )
  492. RTPRssmSetStreamHandler            (RTPReassembler         rtpr,
  493.                                  ComponentInstance         inStreamHandler)                    FIVEWORDINLINE(0x2F3C, 0x0004, 0x0107, 0x7000, 0xA82A);
  494.  
  495. EXTERN_API( ComponentResult )
  496. RTPRssmGetStreamHandler            (RTPReassembler         rtpr,
  497.                                  ComponentInstance *    outStreamHandler)                    FIVEWORDINLINE(0x2F3C, 0x0004, 0x0108, 0x7000, 0xA82A);
  498.  
  499.  
  500. EXTERN_API( ComponentResult )
  501. RTPRssmSendStreamHandlerChanged    (RTPReassembler         rtpr)                                FIVEWORDINLINE(0x2F3C, 0x0000, 0x0109, 0x7000, 0xA82A);
  502.  
  503. EXTERN_API( ComponentResult )
  504. RTPRssmSetSampleDescription        (RTPReassembler         rtpr,
  505.                                  SampleDescriptionHandle  inSampleDescription)                FIVEWORDINLINE(0x2F3C, 0x0004, 0x010A, 0x7000, 0xA82A);
  506.  
  507. /* ----- manually sending chunks*/
  508. EXTERN_API( ComponentResult )
  509. RTPRssmGetChunkAndIncrRefCount    (RTPReassembler         rtpr,
  510.                                  UInt32                 inChunkDataSize,
  511.                                  const TimeValue64 *    inChunkPresentationTime,
  512.                                  SHChunkRecord **        outChunk)                            FIVEWORDINLINE(0x2F3C, 0x000C, 0x010D, 0x7000, 0xA82A);
  513.  
  514. EXTERN_API( ComponentResult )
  515. RTPRssmSendChunkAndDecrRefCount    (RTPReassembler         rtpr,
  516.                                  SHChunkRecord *        inChunk,
  517.                                  const SHServerEditParameters * inServerEdit)                FIVEWORDINLINE(0x2F3C, 0x0008, 0x010E, 0x7000, 0xA82A);
  518.  
  519. EXTERN_API( ComponentResult )
  520. RTPRssmSendLostChunk            (RTPReassembler         rtpr,
  521.                                  const TimeValue64 *    inChunkPresentationTime)            FIVEWORDINLINE(0x2F3C, 0x0004, 0x010F, 0x7000, 0xA82A);
  522.  
  523. EXTERN_API( ComponentResult )
  524. RTPRssmSendStreamBufferRange    (RTPReassembler         rtpr,
  525.                                  RTPSendStreamBufferRangeParams * inParams)                    FIVEWORDINLINE(0x2F3C, 0x0004, 0x0110, 0x7000, 0xA82A);
  526.  
  527. EXTERN_API( ComponentResult )
  528. RTPRssmClearCachedPackets        (RTPReassembler         rtpr,
  529.                                  SInt32                 inFlags)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x0111, 0x7000, 0xA82A);
  530.  
  531. EXTERN_API( ComponentResult )
  532. RTPRssmFillPacketListParams        (RTPReassembler         rtpr,
  533.                                  RTPRssmPacket *        inPacketListHead,
  534.                                  SInt32                 inNumWraparounds,
  535.                                  SInt32                 inFlags)                            FIVEWORDINLINE(0x2F3C, 0x000C, 0x0113, 0x7000, 0xA82A);
  536.  
  537. EXTERN_API( ComponentResult )
  538. RTPRssmReleasePacketList        (RTPReassembler         rtpr,
  539.                                  RTPRssmPacket *        inPacketListHead)                    FIVEWORDINLINE(0x2F3C, 0x0004, 0x0114, 0x7000, 0xA82A);
  540.  
  541. EXTERN_API( ComponentResult )
  542. RTPRssmIncrChunkRefCount        (RTPReassembler         rtpr,
  543.                                  SHChunkRecord *        inChunk)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x0115, 0x7000, 0xA82A);
  544.  
  545. EXTERN_API( ComponentResult )
  546. RTPRssmDecrChunkRefCount        (RTPReassembler         rtpr,
  547.                                  SHChunkRecord *        inChunk)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x0116, 0x7000, 0xA82A);
  548.  
  549. /*============================================================================
  550.         RTP Media Packetizer
  551. ============================================================================*/
  552. enum {
  553.     kRTPMediaPacketizerType        = FOUR_CHAR_CODE('rtpm')
  554. };
  555.  
  556.  
  557. typedef ComponentInstance                 RTPMediaPacketizer;
  558. enum {
  559.     kRTPBaseMediaPacketizerType    = FOUR_CHAR_CODE('gnrc'),
  560.     kRTP261MediaPacketizerType    = FOUR_CHAR_CODE('h261'),
  561.     kRTP263PlusMediaPacketizerType = FOUR_CHAR_CODE('263+'),
  562.     kRTPAudioMediaPacketizerType = FOUR_CHAR_CODE('soun'),
  563.     kRTPQTMediaPacketizerType    = FOUR_CHAR_CODE('qtim'),
  564.     kRTPPureVoiceMediaPacketizerType = FOUR_CHAR_CODE('Qclp'),
  565.     kRTPJPEGMediaPacketizerType    = FOUR_CHAR_CODE('jpeg'),
  566.     kRTPQDesign2MediaPacketizerType = FOUR_CHAR_CODE('QDM2'),
  567.     kRTPSorensonMediaPacketizerType = FOUR_CHAR_CODE('SVQ1')
  568. };
  569.  
  570. typedef UInt32                             RTPMPSampleRef;
  571. typedef CALLBACK_API( void , RTPMPDataReleaseProcPtr )(UInt8 *inData, void *inRefCon);
  572. typedef STACK_UPP_TYPE(RTPMPDataReleaseProcPtr)                 RTPMPDataReleaseUPP;
  573. enum {
  574.     kMediaPacketizerCanPackEditRate = 1 << 0,
  575.     kMediaPacketizerCanPackLayer = 1 << 1,
  576.     kMediaPacketizerCanPackVolume = 1 << 2,
  577.     kMediaPacketizerCanPackBalance = 1 << 3,
  578.     kMediaPacketizerCanPackGraphicsMode = 1 << 4,
  579.     kMediaPacketizerCanPackEmptyEdit = 1 << 5
  580. };
  581.  
  582.  
  583.  
  584. struct MediaPacketizerRequirements {
  585.     OSType                             mediaType;                    /* media type supported (0 for all)*/
  586.     OSType                             dataFormat;                    /* data format (e.g., compression) supported (0 for all)*/
  587.     UInt32                             capabilityFlags;            /* ability to handle non-standard track characteristics*/
  588.     UInt8                             canPackMatrixType;            /* can pack any matrix type up to this (identityMatrixType for identity only)*/
  589.     UInt8                             pad[3];
  590. };
  591. typedef struct MediaPacketizerRequirements MediaPacketizerRequirements;
  592. typedef MediaPacketizerRequirements *    MediaPacketizerRequirementsPtr;
  593.  
  594. struct MediaPacketizerInfo {
  595.     OSType                             mediaType;                    /* media type supported (0 for all)*/
  596.     OSType                             dataFormat;                    /* data format (e.g., compression) supported (0 for all)*/
  597.     OSType                             vendor;                        /* manufacturer of this packetizer (e.g., 'appl' for Apple)*/
  598.     UInt32                             capabilityFlags;            /* ability to handle non-standard track characteristics*/
  599.     UInt8                             canPackMatrixType;            /* can pack any matrix type up to this (identityMatrixType for identity only)*/
  600.     UInt8                             pad[3];
  601.     long                             characteristicCount;
  602.     RTPPayloadCharacteristic         characteristic[1];
  603.  
  604.                                                                 /* after the last characteristic, the payload name (defined by the RTPPayloadInfo*/
  605.                                                                 /* structure) is present. */
  606. };
  607. typedef struct MediaPacketizerInfo        MediaPacketizerInfo;
  608. typedef MediaPacketizerInfo *            MediaPacketizerInfoPtr;
  609. typedef MediaPacketizerInfoPtr *        MediaPacketizerInfoHandle;
  610. #define MediaPacketizerInfoToPayloadInfo(_mpi) ((RTPPayloadInfoPtr)(&((_mpi)->characteristic[(_mpi)->characteristicCount])))
  611. /* MediaPacketizerInfo structs are padded to 32 bits */
  612. enum {
  613.     kMediaPacketizerInfoPadUpToBytes = 4
  614. };
  615.  
  616. EXTERN_API_C( OSErr )
  617. QTSFindMediaPacketizer            (MediaPacketizerRequirementsPtr  inPacketizerinfo,
  618.                                  SampleDescriptionHandle  inSampleDescription,
  619.                                  RTPPayloadSortRequestPtr  inSortInfo,
  620.                                  QTAtomContainer *        outPacketizerList);
  621.  
  622. EXTERN_API_C( OSErr )
  623. QTSFindMediaPacketizerForTrack    (Track                     inTrack,
  624.                                  long                     inSampleDescriptionIndex,
  625.                                  RTPPayloadSortRequestPtr  inSortInfo,
  626.                                  QTAtomContainer *        outPacketizerList);
  627.  
  628. EXTERN_API_C( OSErr )
  629. QTSFindMediaPacketizerForPayloadID (long                 payloadID,
  630.                                  RTPPayloadSortRequestPtr  inSortInfo,
  631.                                  QTAtomContainer *        outPacketizerList);
  632.  
  633. EXTERN_API_C( OSErr )
  634. QTSFindMediaPacketizerForPayloadName (const char *        payloadName,
  635.                                  RTPPayloadSortRequestPtr  inSortInfo,
  636.                                  QTAtomContainer *        outPacketizerList);
  637.  
  638. /* flags for RTPMPInitialize*/
  639. enum {
  640.     kRTPMPRealtimeModeFlag        = 0x00000001
  641. };
  642.  
  643. /* flags for RTPMPSampleDataParams*/
  644. enum {
  645.     kRTPMPSyncSampleFlag        = 0x00000001
  646. };
  647.  
  648.  
  649. struct RTPMPSampleDataParams {
  650.     UInt32                             version;
  651.     UInt32                             timeStamp;
  652.     UInt32                             duration;                    /* 0 = unknown duration*/
  653.     UInt32                             playOffset;
  654.     Fixed                             playRate;
  655.     SInt32                             flags;
  656.     UInt32                             sampleDescSeed;
  657.     Handle                             sampleDescription;
  658.     RTPMPSampleRef                     sampleRef;
  659.     UInt32                             dataLength;
  660.     const UInt8 *                    data;
  661.     RTPMPDataReleaseUPP             releaseProc;
  662.     void *                            refCon;
  663. };
  664. typedef struct RTPMPSampleDataParams    RTPMPSampleDataParams;
  665. /* out flags for idle, RTPMPSetSampleData, and RTPMPFlush*/
  666. enum {
  667.     kRTPMPStillProcessingData    = 0x00000001                    /* not done with data you've got*/
  668. };
  669.  
  670.  
  671. struct RTPMPPayloadTypeParams {
  672.     UInt32                             flags;
  673.     UInt32                             payloadNumber;
  674.     short                             nameLength;                    /* in: size of payloadName buffer (counting null terminator) -- this will be reset to needed length and paramErr returned if too small */
  675.     char *                            payloadName;                /* caller must provide buffer */
  676. };
  677. typedef struct RTPMPPayloadTypeParams    RTPMPPayloadTypeParams;
  678. /*-----------------------------------------
  679.     RTP Media Packetizer Info selectors
  680. -----------------------------------------*/
  681. /* info selectors - get only */
  682. enum {
  683.     kRTPMPPayloadTypeInfo        = FOUR_CHAR_CODE('rtpp'),        /* RTPMPPayloadTypeParams* */
  684.     kRTPMPRTPTimeScaleInfo        = FOUR_CHAR_CODE('rtpt'),        /* TimeScale* */
  685.     kRTPMPRequiredSampleDescriptionInfo = FOUR_CHAR_CODE('sdsc'), /* SampleDescriptionHandle* */
  686.     kRTPMPMinPayloadSize        = FOUR_CHAR_CODE('mins'),        /* UInt32* in bytes, does not include rtp header; default is 0 */
  687.     kRTPMPMinPacketDuration        = FOUR_CHAR_CODE('mind'),        /* UInt3* in milliseconds; default is no min required */
  688.     kRTPMPSuggestedRepeatPktCountInfo = FOUR_CHAR_CODE('srpc'),    /* UInt32* */
  689.     kRTPMPSuggestedRepeatPktSpacingInfo = FOUR_CHAR_CODE('srps'), /* UInt32* in milliseconds */
  690.     kRTPMPMaxPartialSampleSizeInfo = FOUR_CHAR_CODE('mpss'),    /* UInt32* in bytes */
  691.     kRTPMPPreferredBufferDelayInfo = FOUR_CHAR_CODE('prbd'),    /* UInt32* in milliseconds */
  692.     kRTPMPPayloadNameInfo        = FOUR_CHAR_CODE('name')        /* StringPtr */
  693. };
  694.  
  695. /*-----------------------------------------
  696.     RTP Media Packetizer Characteristics
  697. -----------------------------------------*/
  698. /* also supports relevant ones in Movies.h and QTSToolbox.h */
  699. enum {
  700.     kRTPMPNoSampleDataRequiredCharacteristic = FOUR_CHAR_CODE('nsdr'),
  701.     kRTPMPPartialSamplesRequiredCharacteristic = FOUR_CHAR_CODE('ptsr'),
  702.     kRTPMPHasUserSettingsDialogCharacteristic = FOUR_CHAR_CODE('sdlg'),
  703.     kRTPMPPrefersReliableTransportCharacteristic = FOUR_CHAR_CODE('rely'),
  704.     kRTPMPRequiresOutOfBandDimensionsCharacteristic = FOUR_CHAR_CODE('robd')
  705. };
  706.  
  707. /*-----------------------------------------
  708.     RTP Media Packetizer selectors
  709. -----------------------------------------*/
  710. enum {
  711.     kRTPMPInitializeSelect        = 0x0500,
  712.     kRTPMPPreflightMediaSelect    = 0x0501,
  713.     kRTPMPIdleSelect            = 0x0502,
  714.     kRTPMPSetSampleDataSelect    = 0x0503,
  715.     kRTPMPFlushSelect            = 0x0504,
  716.     kRTPMPResetSelect            = 0x0505,
  717.     kRTPMPSetInfoSelect            = 0x0506,
  718.     kRTPMPGetInfoSelect            = 0x0507,
  719.     kRTPMPSetTimeScaleSelect    = 0x0508,
  720.     kRTPMPGetTimeScaleSelect    = 0x0509,
  721.     kRTPMPSetTimeBaseSelect        = 0x050A,
  722.     kRTPMPGetTimeBaseSelect        = 0x050B,
  723.     kRTPMPHasCharacteristicSelect = 0x050C,
  724.     kRTPMPSetPacketBuilderSelect = 0x050E,
  725.     kRTPMPGetPacketBuilderSelect = 0x050F,
  726.     kRTPMPSetMediaTypeSelect    = 0x0510,
  727.     kRTPMPGetMediaTypeSelect    = 0x0511,
  728.     kRTPMPSetMaxPacketSizeSelect = 0x0512,
  729.     kRTPMPGetMaxPacketSizeSelect = 0x0513,
  730.     kRTPMPSetMaxPacketDurationSelect = 0x0514,
  731.     kRTPMPGetMaxPacketDurationSelect = 0x0515,                    /* for export component and apps who want to*/
  732.                                                                 /* access dialogs for Media-specific settings*/
  733.                                                                 /* (such as Pure Voice interleave factor)*/
  734.     kRTPMPDoUserDialogSelect    = 0x0516,
  735.     kRTPMPSetSettingsFromAtomContainerAtAtomSelect = 0x0517,
  736.     kRTPMPGetSettingsIntoAtomContainerAtAtomSelect = 0x0518,
  737.     kRTPMPGetSettingsAsTextSelect = 0x0519
  738. };
  739.  
  740. /*-----------------------------------------
  741.     RTP Media Packetizer functions
  742. -----------------------------------------*/
  743.  
  744. EXTERN_API( ComponentResult )
  745. RTPMPInitialize                    (RTPMediaPacketizer     rtpm,
  746.                                  SInt32                 inFlags)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x0500, 0x7000, 0xA82A);
  747.  
  748. /* return noErr if you can handle this media */
  749. EXTERN_API( ComponentResult )
  750. RTPMPPreflightMedia                (RTPMediaPacketizer     rtpm,
  751.                                  OSType                 inMediaType,
  752.                                  SampleDescriptionHandle  inSampleDescription)                FIVEWORDINLINE(0x2F3C, 0x0008, 0x0501, 0x7000, 0xA82A);
  753.  
  754. /*
  755.    do work here if you need to - give up time periodically
  756.    if you're doing time consuming operations
  757. */
  758. EXTERN_API( ComponentResult )
  759. RTPMPIdle                        (RTPMediaPacketizer     rtpm,
  760.                                  SInt32                 inFlags,
  761.                                  SInt32 *                outFlags)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x0502, 0x7000, 0xA82A);
  762.  
  763. /*
  764.    caller owns the RTPMPSampleDataParams struct
  765.    media Packetizer must copy any fields of the struct it wants to keep
  766.    media Packetizer must call release proc when done with the data
  767.    you can do the processing work here if it does not take up too
  768.    much cpu time - otherwise do it in idle
  769. */
  770. EXTERN_API( ComponentResult )
  771. RTPMPSetSampleData                (RTPMediaPacketizer     rtpm,
  772.                                  const RTPMPSampleDataParams * inSampleData,
  773.                                  SInt32 *                outFlags)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x0503, 0x7000, 0xA82A);
  774.  
  775. /*
  776.    send everything you have buffered - you will get idles while
  777.    you set the kRTPMPStillProcessingData flag here and in idle
  778. */
  779. EXTERN_API( ComponentResult )
  780. RTPMPFlush                        (RTPMediaPacketizer     rtpm,
  781.                                  SInt32                 inFlags,
  782.                                  SInt32 *                outFlags)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x0504, 0x7000, 0xA82A);
  783.  
  784. /*
  785.    dispose of anything buffered and get rid of state
  786.    do not send the buffered data (because presumably
  787.    there is no connection for you to send on)
  788.    state should be the same as if you were just initialized
  789. */
  790. EXTERN_API( ComponentResult )
  791. RTPMPReset                        (RTPMediaPacketizer     rtpm,
  792.                                  SInt32                 inFlags)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x0505, 0x7000, 0xA82A);
  793.  
  794. /*-----------------------------------------
  795.     RTP Media Packetizer get / set functions
  796. -----------------------------------------*/
  797. EXTERN_API( ComponentResult )
  798. RTPMPSetInfo                    (RTPMediaPacketizer     rtpm,
  799.                                  OSType                 inSelector,
  800.                                  const void *            ioParams)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x0506, 0x7000, 0xA82A);
  801.  
  802. EXTERN_API( ComponentResult )
  803. RTPMPGetInfo                    (RTPMediaPacketizer     rtpm,
  804.                                  OSType                 inSelector,
  805.                                  void *                    ioParams)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x0507, 0x7000, 0xA82A);
  806.  
  807. EXTERN_API( ComponentResult )
  808. RTPMPSetTimeScale                (RTPMediaPacketizer     rtpm,
  809.                                  TimeScale                 inTimeScale)                        FIVEWORDINLINE(0x2F3C, 0x0004, 0x0508, 0x7000, 0xA82A);
  810.  
  811. EXTERN_API( ComponentResult )
  812. RTPMPGetTimeScale                (RTPMediaPacketizer     rtpm,
  813.                                  TimeScale *            outTimeScale)                        FIVEWORDINLINE(0x2F3C, 0x0004, 0x0509, 0x7000, 0xA82A);
  814.  
  815. EXTERN_API( ComponentResult )
  816. RTPMPSetTimeBase                (RTPMediaPacketizer     rtpm,
  817.                                  TimeBase                 inTimeBase)                            FIVEWORDINLINE(0x2F3C, 0x0004, 0x050A, 0x7000, 0xA82A);
  818.  
  819. EXTERN_API( ComponentResult )
  820. RTPMPGetTimeBase                (RTPMediaPacketizer     rtpm,
  821.                                  TimeBase *                outTimeBase)                        FIVEWORDINLINE(0x2F3C, 0x0004, 0x050B, 0x7000, 0xA82A);
  822.  
  823. EXTERN_API( ComponentResult )
  824. RTPMPHasCharacteristic            (RTPMediaPacketizer     rtpm,
  825.                                  OSType                 inSelector,
  826.                                  Boolean *                outHasIt)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x050C, 0x7000, 0xA82A);
  827.  
  828. EXTERN_API( ComponentResult )
  829. RTPMPSetPacketBuilder            (RTPMediaPacketizer     rtpm,
  830.                                  ComponentInstance         inPacketBuilder)                    FIVEWORDINLINE(0x2F3C, 0x0004, 0x050E, 0x7000, 0xA82A);
  831.  
  832. EXTERN_API( ComponentResult )
  833. RTPMPGetPacketBuilder            (RTPMediaPacketizer     rtpm,
  834.                                  ComponentInstance *    outPacketBuilder)                    FIVEWORDINLINE(0x2F3C, 0x0004, 0x050F, 0x7000, 0xA82A);
  835.  
  836. EXTERN_API( ComponentResult )
  837. RTPMPSetMediaType                (RTPMediaPacketizer     rtpm,
  838.                                  OSType                 inMediaType)                        FIVEWORDINLINE(0x2F3C, 0x0004, 0x0510, 0x7000, 0xA82A);
  839.  
  840. EXTERN_API( ComponentResult )
  841. RTPMPGetMediaType                (RTPMediaPacketizer     rtpm,
  842.                                  OSType *                outMediaType)                        FIVEWORDINLINE(0x2F3C, 0x0004, 0x0511, 0x7000, 0xA82A);
  843.  
  844. /* size is in bytes*/
  845. EXTERN_API( ComponentResult )
  846. RTPMPSetMaxPacketSize            (RTPMediaPacketizer     rtpm,
  847.                                  UInt32                 inMaxPacketSize)                    FIVEWORDINLINE(0x2F3C, 0x0004, 0x0512, 0x7000, 0xA82A);
  848.  
  849. EXTERN_API( ComponentResult )
  850. RTPMPGetMaxPacketSize            (RTPMediaPacketizer     rtpm,
  851.                                  UInt32 *                outMaxPacketSize)                    FIVEWORDINLINE(0x2F3C, 0x0004, 0x0513, 0x7000, 0xA82A);
  852.  
  853. /* duration is in milliseconds*/
  854. EXTERN_API( ComponentResult )
  855. RTPMPSetMaxPacketDuration        (RTPMediaPacketizer     rtpm,
  856.                                  UInt32                 inMaxPacketDuration)                FIVEWORDINLINE(0x2F3C, 0x0004, 0x0514, 0x7000, 0xA82A);
  857.  
  858. EXTERN_API( ComponentResult )
  859. RTPMPGetMaxPacketDuration        (RTPMediaPacketizer     rtpm,
  860.                                  UInt32 *                outMaxPacketDuration)                FIVEWORDINLINE(0x2F3C, 0x0004, 0x0515, 0x7000, 0xA82A);
  861.  
  862. EXTERN_API( ComponentResult )
  863. RTPMPDoUserDialog                (RTPMediaPacketizer     rtpm,
  864.                                  ModalFilterUPP         inFilterUPP,
  865.                                  Boolean *                canceled)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x0516, 0x7000, 0xA82A);
  866.  
  867. EXTERN_API( ComponentResult )
  868. RTPMPSetSettingsFromAtomContainerAtAtom (RTPMediaPacketizer  rtpm,
  869.                                  QTAtomContainer         inContainer,
  870.                                  QTAtom                 inParentAtom)                        FIVEWORDINLINE(0x2F3C, 0x0008, 0x0517, 0x7000, 0xA82A);
  871.  
  872. EXTERN_API( ComponentResult )
  873. RTPMPGetSettingsIntoAtomContainerAtAtom (RTPMediaPacketizer  rtpm,
  874.                                  QTAtomContainer         inOutContainer,
  875.                                  QTAtom                 inParentAtom)                        FIVEWORDINLINE(0x2F3C, 0x0008, 0x0518, 0x7000, 0xA82A);
  876.  
  877. EXTERN_API( ComponentResult )
  878. RTPMPGetSettingsAsText            (RTPMediaPacketizer     rtpm,
  879.                                  Handle *                text)                                FIVEWORDINLINE(0x2F3C, 0x0004, 0x0519, 0x7000, 0xA82A);
  880.  
  881.  
  882. /*============================================================================
  883.         RTP Packet Builder
  884. ============================================================================*/
  885. enum {
  886.     kRTPPacketBuilderType        = FOUR_CHAR_CODE('rtpb')
  887. };
  888.  
  889.  
  890. typedef ComponentInstance                 RTPPacketBuilder;
  891. typedef struct OpaqueRTPPacketGroupRef*  RTPPacketGroupRef;
  892. typedef struct OpaqueRTPPacketRef*         RTPPacketRef;
  893. typedef struct OpaqueRTPPacketRepeatedDataRef*  RTPPacketRepeatedDataRef;
  894. /* flags for RTPPBBegin/EndPacket, RTPPBBegin/EndPacketGroup*/
  895. enum {
  896.     kRTPPBSetMarkerFlag            = 0x00000001,
  897.     kRTPPBRepeatPacketFlag        = 0x00000002,
  898.     kRTPPBSyncSampleFlag        = 0x00010000,
  899.     kRTPPBBFrameFlag            = 0x00020000,
  900.     kRTPPBDontSendFlag            = 0x10000000                    /* when set in EndPacketGroup, will not add group*/
  901. };
  902.  
  903. enum {
  904.     kRTPPBUnknownPacketMediaDataLength = 0
  905. };
  906.  
  907. typedef CALLBACK_API( void , RTPPBCallbackProcPtr )(OSType inSelector, void *ioParams, void *inRefCon);
  908. typedef STACK_UPP_TYPE(RTPPBCallbackProcPtr)                     RTPPBCallbackUPP;
  909. /*-----------------------------------------
  910.     RTP Packet Builder selectors
  911. -----------------------------------------*/
  912. enum {
  913.     kRTPPBBeginPacketGroupSelect = 0x0500,
  914.     kRTPPBEndPacketGroupSelect    = 0x0501,
  915.     kRTPPBBeginPacketSelect        = 0x0502,
  916.     kRTPPBEndPacketSelect        = 0x0503,
  917.     kRTPPBAddPacketLiteralDataSelect = 0x0504,
  918.     kRTPPBAddPacketSampleDataSelect = 0x0505,
  919.     kRTPPBAddPacketRepeatedDataSelect = 0x0506,
  920.     kRTPPBReleaseRepeatedDataSelect = 0x0507,
  921.     kRTPPBSetPacketSequenceNumberSelect = 0x0508,
  922.     kRTPPBGetPacketSequenceNumberSelect = 0x0509,
  923.     kRTPPBSetCallbackSelect        = 0x050A,
  924.     kRTPPBGetCallbackSelect        = 0x050B,
  925.     kRTPPBSetInfoSelect            = 0x050C,
  926.     kRTPPBGetInfoSelect            = 0x050D
  927. };
  928.  
  929. /*-----------------------------------------
  930.     RTP Packet Builder functions
  931. -----------------------------------------*/
  932. EXTERN_API( ComponentResult )
  933. RTPPBBeginPacketGroup            (RTPPacketBuilder         rtpb,
  934.                                  SInt32                 inFlags,
  935.                                  UInt32                 inTimeStamp,
  936.                                  RTPPacketGroupRef *    outPacketGroup)                        FIVEWORDINLINE(0x2F3C, 0x000C, 0x0500, 0x7000, 0xA82A);
  937.  
  938. EXTERN_API( ComponentResult )
  939. RTPPBEndPacketGroup                (RTPPacketBuilder         rtpb,
  940.                                  SInt32                 inFlags,
  941.                                  RTPPacketGroupRef         inPacketGroup)                        FIVEWORDINLINE(0x2F3C, 0x0008, 0x0501, 0x7000, 0xA82A);
  942.  
  943. EXTERN_API( ComponentResult )
  944. RTPPBBeginPacket                (RTPPacketBuilder         rtpb,
  945.                                  SInt32                 inFlags,
  946.                                  RTPPacketGroupRef         inPacketGroup,
  947.                                  UInt32                 inPacketMediaDataLength,
  948.                                  RTPPacketRef *            outPacket)                            FIVEWORDINLINE(0x2F3C, 0x0010, 0x0502, 0x7000, 0xA82A);
  949.  
  950. EXTERN_API( ComponentResult )
  951. RTPPBEndPacket                    (RTPPacketBuilder         rtpb,
  952.                                  SInt32                 inFlags,
  953.                                  RTPPacketGroupRef         inPacketGroup,
  954.                                  RTPPacketRef             inPacket,
  955.                                  UInt32                 inTimeOffset,
  956.                                  UInt32                 inDuration)                            FIVEWORDINLINE(0x2F3C, 0x0014, 0x0503, 0x7000, 0xA82A);
  957.  
  958. /*
  959.    non-NULL RTPPacketRepeatedDataRef means this data will be repeated later
  960.    pb must return a repeated data ref
  961. */
  962. EXTERN_API( ComponentResult )
  963. RTPPBAddPacketLiteralData        (RTPPacketBuilder         rtpb,
  964.                                  SInt32                 inFlags,
  965.                                  RTPPacketGroupRef         inPacketGroup,
  966.                                  RTPPacketRef             inPacket,
  967.                                  UInt8 *                inData,
  968.                                  UInt32                 inDataLength,
  969.                                  RTPPacketRepeatedDataRef * outDataRef)                        FIVEWORDINLINE(0x2F3C, 0x0018, 0x0504, 0x7000, 0xA82A);
  970.  
  971. /*
  972.    non-NULL RTPPacketRepeatedDataRef means this data will be repeated later
  973.    pb must return a repeated data ref
  974. */
  975. EXTERN_API( ComponentResult )
  976. RTPPBAddPacketSampleData        (RTPPacketBuilder         rtpb,
  977.                                  SInt32                 inFlags,
  978.                                  RTPPacketGroupRef         inPacketGroup,
  979.                                  RTPPacketRef             inPacket,
  980.                                  RTPMPSampleDataParams * inSampleDataParams,
  981.                                  UInt32                 inSampleOffset,
  982.                                  UInt32                 inSampleDataLength,
  983.                                  RTPPacketRepeatedDataRef * outDataRef)                        FIVEWORDINLINE(0x2F3C, 0x001C, 0x0505, 0x7000, 0xA82A);
  984.  
  985. /*
  986.    call to add the repeated data using the ref you got from
  987.    RTPPBAddPacketLiteralData or RTPPBAddPacketSampleData
  988. */
  989. EXTERN_API( ComponentResult )
  990. RTPPBAddPacketRepeatedData        (RTPPacketBuilder         rtpb,
  991.                                  SInt32                 inFlags,
  992.                                  RTPPacketGroupRef         inPacketGroup,
  993.                                  RTPPacketRef             inPacket,
  994.                                  RTPPacketRepeatedDataRef  inDataRef)                        FIVEWORDINLINE(0x2F3C, 0x0010, 0x0506, 0x7000, 0xA82A);
  995.  
  996. /* call when done with repeated data*/
  997. EXTERN_API( ComponentResult )
  998. RTPPBReleaseRepeatedData        (RTPPacketBuilder         rtpb,
  999.                                  RTPPacketRepeatedDataRef  inDataRef)                        FIVEWORDINLINE(0x2F3C, 0x0004, 0x0507, 0x7000, 0xA82A);
  1000.  
  1001. /*
  1002.    seq number is just relative seq number
  1003.    don't call if you don't care when seq # is used
  1004. */
  1005. EXTERN_API( ComponentResult )
  1006. RTPPBSetPacketSequenceNumber    (RTPPacketBuilder         rtpb,
  1007.                                  SInt32                 inFlags,
  1008.                                  RTPPacketGroupRef         inPacketGroup,
  1009.                                  RTPPacketRef             inPacket,
  1010.                                  UInt32                 inSequenceNumber)                    FIVEWORDINLINE(0x2F3C, 0x0010, 0x0508, 0x7000, 0xA82A);
  1011.  
  1012. EXTERN_API( ComponentResult )
  1013. RTPPBGetPacketSequenceNumber    (RTPPacketBuilder         rtpb,
  1014.                                  SInt32                 inFlags,
  1015.                                  RTPPacketGroupRef         inPacketGroup,
  1016.                                  RTPPacketRef             inPacket,
  1017.                                  UInt32 *                outSequenceNumber)                    FIVEWORDINLINE(0x2F3C, 0x0010, 0x0509, 0x7000, 0xA82A);
  1018.  
  1019. /*
  1020.    used for communicating with the caller of the media packetizers if needed
  1021.    NOT used for communicating with the media packetizers themselves
  1022. */
  1023. EXTERN_API( ComponentResult )
  1024. RTPPBSetCallback                (RTPPacketBuilder         rtpb,
  1025.                                  RTPPBCallbackUPP         inCallback,
  1026.                                  void *                    inRefCon)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x050A, 0x7000, 0xA82A);
  1027.  
  1028. EXTERN_API( ComponentResult )
  1029. RTPPBGetCallback                (RTPPacketBuilder         rtpb,
  1030.                                  RTPPBCallbackUPP *        outCallback,
  1031.                                  void **                outRefCon)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x050B, 0x7000, 0xA82A);
  1032.  
  1033. EXTERN_API( ComponentResult )
  1034. RTPPBSetInfo                    (RTPPacketBuilder         rtpb,
  1035.                                  OSType                 inSelector,
  1036.                                  void *                    ioParams)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x050C, 0x7000, 0xA82A);
  1037.  
  1038. EXTERN_API( ComponentResult )
  1039. RTPPBGetInfo                    (RTPPacketBuilder         rtpb,
  1040.                                  OSType                 inSelector,
  1041.                                  void *                    ioParams)                            FIVEWORDINLINE(0x2F3C, 0x0008, 0x050D, 0x7000, 0xA82A);
  1042.  
  1043.  
  1044. /* UPP call backs */
  1045. #if OPAQUE_UPP_TYPES
  1046.     EXTERN_API(RTPMPDataReleaseUPP)
  1047.     NewRTPMPDataReleaseUPP           (RTPMPDataReleaseProcPtr    userRoutine);
  1048.  
  1049.     EXTERN_API(RTPPBCallbackUPP)
  1050.     NewRTPPBCallbackUPP               (RTPPBCallbackProcPtr    userRoutine);
  1051.  
  1052.     EXTERN_API(void)
  1053.     DisposeRTPMPDataReleaseUPP       (RTPMPDataReleaseUPP        userUPP);
  1054.  
  1055.     EXTERN_API(void)
  1056.     DisposeRTPPBCallbackUPP           (RTPPBCallbackUPP        userUPP);
  1057.  
  1058.     EXTERN_API(void)
  1059.     InvokeRTPMPDataReleaseUPP       (UInt8 *                    inData,
  1060.                                     void *                    inRefCon,
  1061.                                     RTPMPDataReleaseUPP        userUPP);
  1062.  
  1063.     EXTERN_API(void)
  1064.     InvokeRTPPBCallbackUPP           (OSType                    inSelector,
  1065.                                     void *                    ioParams,
  1066.                                     void *                    inRefCon,
  1067.                                     RTPPBCallbackUPP        userUPP);
  1068.  
  1069. #else
  1070.     enum { uppRTPMPDataReleaseProcInfo = 0x000003C0 };                 /* pascal no_return_value Func(4_bytes, 4_bytes) */
  1071.     enum { uppRTPPBCallbackProcInfo = 0x00000FC0 };                 /* pascal no_return_value Func(4_bytes, 4_bytes, 4_bytes) */
  1072.     #define NewRTPMPDataReleaseUPP(userRoutine)                     (RTPMPDataReleaseUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppRTPMPDataReleaseProcInfo, GetCurrentArchitecture())
  1073.     #define NewRTPPBCallbackUPP(userRoutine)                         (RTPPBCallbackUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppRTPPBCallbackProcInfo, GetCurrentArchitecture())
  1074.     #define DisposeRTPMPDataReleaseUPP(userUPP)                     DisposeRoutineDescriptor(userUPP)
  1075.     #define DisposeRTPPBCallbackUPP(userUPP)                         DisposeRoutineDescriptor(userUPP)
  1076.     #define InvokeRTPMPDataReleaseUPP(inData, inRefCon, userUPP)     CALL_TWO_PARAMETER_UPP((userUPP), uppRTPMPDataReleaseProcInfo, (inData), (inRefCon))
  1077.     #define InvokeRTPPBCallbackUPP(inSelector, ioParams, inRefCon, userUPP)  CALL_THREE_PARAMETER_UPP((userUPP), uppRTPPBCallbackProcInfo, (inSelector), (ioParams), (inRefCon))
  1078. #endif
  1079. /* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
  1080. #define NewRTPMPDataReleaseProc(userRoutine)                     NewRTPMPDataReleaseUPP(userRoutine)
  1081. #define NewRTPPBCallbackProc(userRoutine)                         NewRTPPBCallbackUPP(userRoutine)
  1082. #define CallRTPMPDataReleaseProc(userRoutine, inData, inRefCon)    InvokeRTPMPDataReleaseUPP(inData, inRefCon, userRoutine)
  1083. #define CallRTPPBCallbackProc(userRoutine, inSelector, ioParams, inRefCon) InvokeRTPPBCallbackUPP(inSelector, ioParams, inRefCon, userRoutine)
  1084.  
  1085. #if PRAGMA_STRUCT_ALIGN
  1086.     #pragma options align=reset
  1087. #elif PRAGMA_STRUCT_PACKPUSH
  1088.     #pragma pack(pop)
  1089. #elif PRAGMA_STRUCT_PACK
  1090.     #pragma pack()
  1091. #endif
  1092.  
  1093. #ifdef PRAGMA_IMPORT_OFF
  1094. #pragma import off
  1095. #elif PRAGMA_IMPORT
  1096. #pragma import reset
  1097. #endif
  1098.  
  1099. #ifdef __cplusplus
  1100. }
  1101. #endif
  1102.  
  1103. #endif /* __QTSTREAMINGCOMPONENTS__ */
  1104.  
  1105.